hysop.backend.host.python.operator.vorticity_absorption module

class hysop.backend.host.python.operator.vorticity_absorption.PythonVorticityAbsorption(velocity, vorticity, dt, flowrate, start_coord, variables, custom_filter=None, implementation=None, **kwds)[source]

Bases: HostOperator

Python implementation of the vorticity absorption at domain outlet.

Parameters:

  • velocity (field) – input velocity

  • vorticity (field) – input vorticity

  • flowrate (ScalarParameter) – penalization factor applied to all geometries. Flowrate is given in XYZ components.

  • start_coord (coordinate of the absorption filter start (X coord))

  • custom_filter (sympy expression) – The formula to be applied onto the field.

  • variables (dict) – dictionary of fields as keys and topologies as values.

  • dt (ScalarParameter) – Timestep parameter that will be used for time integration.

  • implementation (Implementation, optional, defaults to None) – target implementation, should be contained in available_implementations(). If None, implementation will be set to default_implementation().

  • kwds – Keywords arguments that will be passed towards implementation poisson operator __init__.

apply(**kwds)

Abstract method that should be implemented. Applies this node (operator, computational graph operator…).

discretize()[source]

By default, an operator discretize all its variables. For each input continuous field that is also an output field, input topology may be different from the output topology.

After this call, one can access self.input_discrete_fields and self.output_discrete_fields, which contains input and output dicretised fields mapped by continuous fields.

self.discrete_fields will be a tuple containing all input and output discrete fields.

Discrete tensor fields are built back from discretized scalar fields and are accessible from self.input_tensor_fields, self.output_tensor_fields and self.discrete_tensor_fields like their scalar counterpart.

get_field_requirements()[source]

Called just after handle_method(), ie self.method has been set. Field requirements are:

  1. required local and global transposition state, if any.

  2. required memory ordering (either C or Fortran)

Default is Backend.HOST, no min or max ghosts, MemoryOrdering.ANY and no specific default transposition state for each input and output variables.

get_work_properties()[source]

Returns extra memory requirements of this operator. This allows operators to request for temporary buffers that will be shared between operators in a graph to reduce the memory footprint and the number of allocations.

Returned memory is only usable during operator call (ie. in self.apply). Temporary buffers may be shared between different operators as determined by the graph builder.

By default if there is no input nor output temprary fields, this returns no requests, meanning that this node requires no extra buffers.

If temporary fields are present, their memory request are automatically computed and returned.

setup(work)[source]

Setup temporary buffer that have been requested in get_work_properties(). This function may be used to execute post allocation routines. This sets self.ready flag to True. Once this flag is set one may call ComputationalGraphNode.apply() and ComputationalGraphNode.finalize().

Automatically honour temporary field memory requests.

classmethod supported_dimensions()[source]
classmethod supports_mpi()[source]

Return True if this operator was implemented to support multiple mpi processes.